#include <thread>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <queue>
#include <functional>
#include <atomic>
#include <iostream>
class MainThreadDispatcher
{
private:
    std::queue<std::function<void()>> m_queue;
    std::mutex m_mutex;

    std::condition_variable queue_condition_;
    std::atomic<bool> shutdown_{false};
public:
    MainThreadDispatcher(/* args */) = default;
    ~MainThreadDispatcher() = default;

    // 其他线程调用，将事件片加入队列
    void dispatch_to_main(std::function<void()> func)
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_queue.push(func);
        queue_condition_.notify_one();
    }

    void run_main_thread_events()
    {
        std::queue<std::function<void()>> local_queue;
            
        // 只在转移事件时加锁
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            local_queue.swap(m_queue);  // // 通过快速交换队列最小化锁持有时间
        }
        
        // 在无锁状态下执行所有事件
        while (!local_queue.empty()) {
            auto event = std::move(local_queue.front());
            local_queue.pop();
            if (event) {
                event();  // 在无锁状态下执行
            }
        }
    }

    // 阻塞等待事件处理
    void process_events_blocking() {
        while (!shutdown_) {
            std::unique_lock<std::mutex> lock(m_mutex);
            queue_condition_.wait(lock, [this] { 
                return !m_queue.empty() || shutdown_; 
            });
            
            if (shutdown_ && m_queue.empty()) {
                break;
            }
            
            auto local_queue = std::move(m_queue);
            lock.unlock();  // 释放锁后再执行
            
            while (!local_queue.empty()) {
                auto event = std::move(local_queue.front());
                local_queue.pop();
                if (event) {
                    event();
                }
            }
        }
    }
    
    // 添加public shutdown方法
    void shutdown() {
        shutdown_ = true;
        queue_condition_.notify_all();
    }
};

void test()
{
    MainThreadDispatcher dispatcher;
    std::thread t1([&dispatcher]() {
        dispatcher.process_events_blocking();
    });
    std::thread t2([&dispatcher]() {
        dispatcher.dispatch_to_main([]() {
            std::cout << "Hello from thread 2" << std::endl;
        });
    }); 
}
int main()
{
    MainThreadDispatcher dispatcher;
    
    // 启动工作线程
    std::thread worker([&dispatcher]() {
        // 工作线程向主线程派发任务
        dispatcher.dispatch_to_main([]() {
            std::cout << "Task executed on main thread" << std::endl;
        });
    });
    
    // 主线程处理事件 - 这才是正确的方式
    for (;;) {
        dispatcher.run_main_thread_events();
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    
    worker.join();
    return 0;
}

// int main()
// {
//     MainThreadDispatcher dispatcher;
//     Application app;
    
//     // 启动后台线程处理网络请求
//     std::thread network_thread([&dispatcher]() {
//         // 网络操作完成后，向主线程派发UI更新任务
//         auto result = perform_network_request();
//         dispatcher.dispatch_to_main([result]() {
//             // 在主线程中安全地更新UI
//             update_ui_with_result(result);
//         });
//     });
    
//     // 主线程运行GUI事件循环
//     while (app.is_running()) {
//         app.process_gui_events();           // 处理GUI事件
//         dispatcher.run_main_thread_events(); // 处理派发的任务
//         app.render();                       // 渲染界面
//     }
    
//     network_thread.join();
//     return 0;
// }